package com.ruoyi.door.service;

import com.easy.query.api.proxy.client.EasyEntityQuery;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.door.controller.admin.dept.vo.DoorDeptImportVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class DoorDeptService {
    @Autowired
    private EasyEntityQuery easyEntityQuery;

    /**
     * 导入部门数据
     * 
     * @param list 部门数据列表
     * @param updateSupport 是否更新已存在的部门
     * @return 结果
     */
    @Transactional(rollbackFor = Exception.class)
    public String importData(List<DoorDeptImportVO> list, boolean updateSupport) {
        if (StringUtils.isNull(list) || list.size() == 0) {
            throw new ServiceException("导入部门数据不能为空！");
        }
        
        int successCount = 0;
        int failCount = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        
        // 缓存已处理的部门，避免重复查询
        Map<String, SysDept> deptCache = new HashMap<>();
        
        for (DoorDeptImportVO vo : list) {
            try {
                // 验证必填字段
                if (StringUtils.isEmpty(vo.getCountryName())) {
                    failureMsg.append("<br/>部门 ").append(vo.toString()).append(" 导入失败：国家名称不能为空");
                    failCount++;
                    continue;
                }
                
                // 验证数据完整性
                if (StringUtils.isNotEmpty(vo.getVillageName()) && StringUtils.isEmpty(vo.getStreetName())) {
                    failureMsg.append("<br/>部门 ").append(vo.toString()).append(" 导入失败：存在村级数据时街道不能为空");
                    failCount++;
                    continue;
                }
                if (StringUtils.isNotEmpty(vo.getStreetName()) && StringUtils.isEmpty(vo.getDistrictName())) {
                    failureMsg.append("<br/>部门 ").append(vo.toString()).append(" 导入失败：存在街道数据时区县不能为空");
                    failCount++;
                    continue;
                }
                if (StringUtils.isNotEmpty(vo.getDistrictName()) && StringUtils.isEmpty(vo.getCityName())) {
                    failureMsg.append("<br/>部门 ").append(vo.toString()).append(" 导入失败：存在区县数据时城市不能为空");
                    failCount++;
                    continue;
                }
                if (StringUtils.isNotEmpty(vo.getCityName()) && StringUtils.isEmpty(vo.getProvinceName())) {
                    failureMsg.append("<br/>部门 ").append(vo.toString()).append(" 导入失败：存在城市数据时省份不能为空");
                    failCount++;
                    continue;
                }
                
                // 使用新方法处理部门层级关系
                SysDept lastDept = findOrCreateDept(vo, deptCache);
                
                successCount++;
                successMsg.append("<br/>").append(vo.toString()).append(" 导入成功");
            } catch (Exception e) {
                failCount++;
                String msg = "<br/>部门 " + vo.toString() + " 导入失败：" + e.getMessage();
                failureMsg.append(msg);
                log.error(msg, e);
            }
        }
        
        if (failCount > 0) {
            failureMsg.insert(0, "很抱歉，导入失败！共 " + failCount + " 条数据格式不正确，错误如下：");
            throw new ServiceException(failureMsg.toString());
        } else {
            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successCount + " 条，数据如下：");
        }
        
        return successMsg.toString();
    }
    
    /**
     * 查找或创建部门
     * 
     * @param deptName 部门名称
     * @param level 部门层级
     * @param parentId 上级部门ID
     * @param deptCache 部门缓存
     * @param updateSupport 是否更新已存在的部门
     * @return 部门对象
     */
    /**
     * 查找或创建部门，并建立正确的层级关系
     */
    private SysDept findOrCreateDept(DoorDeptImportVO vo, Map<String, SysDept> deptCache) {
        // 处理国家级部门 (level = 1)
        String countryName = vo.getCountryName();
        if (StringUtils.isEmpty(countryName)) {
            throw new ServiceException("国家名称不能为空");
        }
        
        // 查找或创建国家级部门（parentId=0）
        SysDept countryDept = findOrCreateSingleDept(countryName, 0L, 1, deptCache);
        
        // 如果只有国家级，直接返回
        if (StringUtils.isEmpty(vo.getProvinceName())) {
            return countryDept;
        }
        
        // 查找或创建省级部门
        SysDept provinceDept = findOrCreateSingleDept(vo.getProvinceName(), countryDept.getDeptId(), 2, deptCache);
        
        // 如果只到省级，直接返回
        if (StringUtils.isEmpty(vo.getCityName())) {
            return provinceDept;
        }
        
        // 查找或创建市级部门
        SysDept cityDept = findOrCreateSingleDept(vo.getCityName(), provinceDept.getDeptId(), 3, deptCache);
        
        // 如果只到市级，直接返回
        if (StringUtils.isEmpty(vo.getDistrictName())) {
            return cityDept;
        }
        
        // 查找或创建区级部门
        SysDept districtDept = findOrCreateSingleDept(vo.getDistrictName(), cityDept.getDeptId(), 4, deptCache);
        
        // 如果只到区级，直接返回
        if (StringUtils.isEmpty(vo.getStreetName())) {
            return districtDept;
        }
        
        // 查找或创建街道级部门
        SysDept streetDept = findOrCreateSingleDept(vo.getStreetName(), districtDept.getDeptId(), 5, deptCache);
        
        // 如果只到街道级，直接返回
        if (StringUtils.isEmpty(vo.getVillageName())) {
            return streetDept;
        }
        
        // 查找或创建村级部门
        return findOrCreateSingleDept(vo.getVillageName(), streetDept.getDeptId(), 6, deptCache);
    }
    
    /**
     * 查找或创建单个部门
     */
    private SysDept findOrCreateSingleDept(String deptName, Long parentId, int level, Map<String, SysDept> deptCache) {
        // 生成缓存键
        String cacheKey = level + ":" + parentId + ":" + deptName;
        
        // 检查缓存
        if (deptCache.containsKey(cacheKey)) {
            return deptCache.get(cacheKey);
        }
        
        // 构建ancestors
        String ancestors = "0";
        if (parentId != null && parentId > 0) {
            SysDept parentDept = easyEntityQuery.queryable(SysDept.class)
                    .where(x -> x.deptId().eq(parentId))
                    .firstOrNull();
            
            if (parentDept == null) {
                throw new ServiceException("上级部门不存在");
            }
            ancestors = parentDept.getAncestors() + "," + parentId;
        }
        
        // 查询是否已存在相同名称和父级的部门
        SysDept existDept = easyEntityQuery.queryable(SysDept.class)
                .where(x -> {
                    x.deptName().eq(deptName);
                    if (parentId != null && parentId > 0) {
                        x.parentId().eq(parentId);
                    } else {
                        x.parentId().eq(0L);
                    }
                })
                .firstOrNull();
        
        if (existDept != null) {
            // 添加到缓存
            deptCache.put(cacheKey, existDept);
            return existDept;
        }
        
        // 创建新部门
        SysDept newDept = new SysDept();
        newDept.setDeptName(deptName);
        // 如果parentId为0，则设置为0L，否则使用传入的parentId
        newDept.setParentId(parentId != null && parentId > 0 ? parentId : 0L);
        newDept.setAncestors(ancestors);
        newDept.setOrderNum(level * 10);
        newDept.setStatus("0");
        newDept.setLevel(level);
        
        // 插入数据库
        easyEntityQuery.insertable(newDept).executeRows(true);
        
        // 添加到缓存
        deptCache.put(cacheKey, newDept);
        return newDept;
    }
}
